package someTestExcemple.huaweiOd.container.tree;
import java.util.*;
public class LineCoveredOD {
    public static void main(String[] args) {
        Node[] arr = new Node[10000];
        Scanner sc = new Scanner(System.in);
        // 输入所有线段的数量n
        int n = sc.nextInt();
        // 输入n个Node节点，有两个值，起点和终点
        for (int i = 0; i < n; i++) {
            String[] s = sc.next().split(",");
            arr[i] = new Node(Integer.parseInt(s[0]), Integer.parseInt(s[1]));
        }

        // 将输入的Node节点进行排序，根据Node左节点进行升序排列
        Arrays.sort(arr, 0, n - 1);

        int ret = 1;
        // 第一个节点的右节点
        int right = arr[0].r;
        // 最大右节点，初始化为第一个节点的右节点
        int maxRight = arr[0].r;
        for (int i = 1; i < n; i++) {
            // 如果之后的左节点大于第一个右节点
            if (arr[i].l > right) {
                // 比较最大右节点与当前的右节点
                if (maxRight > right) {
                    ret++;
                    right = maxRight;
                }
                if (maxRight < arr[i].l) {
                    ret++;
                    right = arr[i].r;
                }
            }
            // 获取最大右节点
            maxRight = Math.max(arr[i].r, maxRight);
        }
        if (maxRight > right) {
            ret++;
        }
        System.out.println(ret);
    }

    /**
     * 定义一个节点，有左节点和右节点两个属性
     */
    static class Node implements Comparable<Node> {
        int l, r;

        public Node(int l, int r) {
            this.l = l;
            this.r = r;
        }

        /**
         * 和当前结点进行比较
         * 如果当前node和参数node的左节点相当，返回参数右节点与当前的右节点差
         * 如果当前node和参数node的左节点不相当，返回当前node和参数node的左节点的差值
         * @param o
         * @return
         */
        @Override
        public int compareTo(Node o) {
            if (l == o.l) {
                return o.r - r;
            }
            return l - o.l;
        }
    }
}
